What does this check? I was expecting to read isinstance(kind, (type(None), str)) instead of seeing a |. For my education, what is the difference/when would I use one and when the other?

It's a union type, https://peps.python.org/pep-0604/. AFAIU the two isinstance forms are exactly equivalent.

FWIW, I also expect(ed) a tuple of types but apparently multiple linters pick on this in their "modernization" recommendations, similar to % string formatting. And some scipy reviewers felt strongly enough --- the sum total effect is apparently that my finger memory changed from (int, float) to int | float.

Every day is a school day! Thanks for the explanation

Shouldn't it be isinstance(kind, None | str) instead of using type(None)? In the PEP that form appears a few times. Python might slowly be getting too complicated for my brain

Experimentally, this form does not seem to work:

In [8]: isinstance(None, None)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[8], line 1
----> 1 isinstance(None, None)

TypeError: isinstance() arg 2 must be a type, a tuple of types, or a union

In [9]: isinstance(None, type(None))
Out[9]: True

Have to admit I only got the PEP reference from a google search, and I'm not sure of exact details of whether instances should or should not be allowed as the 2nd isinstance argument, or whether there were post-pep decisions, or if different python versions do different things.

Here type(None) is what just worked so that I did not have to stop looking for alternatives. Apparently, there's from types import NoneType which I just now had to look up where it is defined (and am pretty sure will need to look it up again next time). If type(None) rubs the reader the wrong way, we can switch to that of course.
So yeah, python is getting too complicated for my brain, too :-).

Ah, here's the thing:

This PEP is a historical document. The up-to-date, canonical documentation can now be found at Union Type.

Looking at the Union Type reference,

int | str == typing.Union[int, str]

and

Optional types can be spelled as a union with None:
str | None == typing.Optional[str]

So int | None and int | type(None) are different. I'm sure there's a convincing argument (~100 comments somewhere) that isinstance receives a Union not Optional. Sigh.